//最小覆盖子串 ——滑动窗口
class Solution {
public:
    unordered_map<char,int> window;
    unordered_map<char,int> standard;
    bool check()
    {
        for(auto p:standard)
        {
            if(window[p.first]<p.second) return false;
        }
        return true;
    }
    string minWindow(string s, string t) 
    {
        //先将t全部放入标准哈希映射
        for(auto ch:t)
        {
            standard[ch]++;
        }
        int l=0,r=0;
        int len=INT_MAX;
        int index=-1;
        while(r<s.size())
        {
            //开始遍历S 如果出现了t单词中的字母 标记一下好确认是否全部出现
            if(standard.find(s[r])!=standard.end() )
            {
                window[s[r]]++;
            }
            while(check() && l<=r)
            {
                //现在整个窗口包换了t的所有字母
                //查看左边界能不能往里缩
                
                //先记录这次结果
                if(r-l+1<len)
                {
                    index=l;
                    len=r-l+1;
                }

                //现在往里一个一个挨着删
                if(standard.find(s[l])!=standard.end() )
                {
                    //删到 t里面的字母了 那把window里面的该字母也删了
                    window[s[l]]--;
                }
                l++;
            }
            r++;
        }
        return index==-1?string():s.substr(index,len);

    }
};

//子集
class Solution {
public:
    vector<int>tmp;
    vector<vector<int>>res;
    vector<vector<int>> subsets(vector<int>& nums) 
    {
        if(nums.size()==0) return res;
        dfs(nums,0);
        return res;
    }
    void dfs(vector<int>& nums,int curi)
    {
        res.push_back(tmp);
        if(tmp.size()>=nums.size())
        {
            return ;
        }
        for(int i=curi;i<nums.size();i++)
        {
            tmp.push_back(nums[i]);
            dfs(nums,i+1);
            tmp.pop_back();
        }
    }
};

//扑克牌大小

#include <iostream>
using namespace std;

//思路：除了炸弹和对王 必须同类型比较，那什么情况才是同类型？
//当两幅排的大小一样时，才是同类型！
//而且炸弹有两种情况 一是双方都是炸弹 为同类型比较
//二是 只有一方是炸弹 直接输出炸弹即可。
//整个游戏中最特殊的就是王炸 遇到了就直接输出它
//所以在一开始进行判断的时候，就把王炸剔除出来可以减少判断。


//该函数用于计算手牌中牌的个数
//不能找数字 而要找空格 因为 10是两个字符！！
int getcardnum(string& str)
{
    //
    int count=0;
    for(auto& ch:str)
    {
        if(ch==' ') count++;
    }
    return count+1;
}

string compare(string& s1,string& s2)
{
    if(s1.find("joker JOKER")!=string::npos 
        ||s2.find("joker JOKER")!=string::npos )
    {
        return string()="joker JOKER";
    }
    //王炸去掉之后 比较只剩下两种 两副手牌个数相同
    //两副手牌个数不同
    int leftsize=getcardnum(s1);
    int rightsize=getcardnum(s2);
    if(leftsize==rightsize)
    {
        //找最小的那个数进行比较即可
        string Lfirst=s1.substr(0,s1.find(' '));
        string Rfirst=s2.substr(0,s2.find(' '));
        static string order="345678910JQKA2jokerJOKER";
        if(order.find(Lfirst) < order.find(Rfirst))
        {
            return s2;
        }
        else return s1;
    }
    else  
    {
        if(leftsize==4) return s1;
        else if(rightsize==4) return s2;
        else return string()="ERROR";
    }
    return string();
}

int main() 
{
    string str;
    getline(cin,str);
    //因为是一次性输入了两幅牌 首先需要将两副手牌拆开——找'-'
    int index=0;
    for(int i=0;i<str.size();i++)
    {
        if(str[i]=='-') index=i;
    }
    string s1=str.substr(0,index);
    string s2=str.substr(index+1);
    cout<<compare(s1, s2)<<endl;
    return 0;
}